import websocketManager from './websocket.js'
import chatApi from '@/api/chat.js'

/**
 * 聊天管理器
 * 统一管理聊天相关功能
 */
class ChatManager {
    constructor() {
        this.isInitialized = false;
        this.unreadCount = 0; // 总未读消息数
        this.sessionList = []; // 会话列表
        this.currentChatUserId = null; // 当前正在聊天的用户ID
        this.messageHandlers = new Map(); // 消息处理器
        this.init();
    }

    /**
     * 初始化聊天管理器
     */
    init() {
        if (this.isInitialized) return;

        console.log('开始初始化聊天管理器...');

        // 创建绑定的方法引用，避免this上下文丢失
        this.boundHandleWebSocketMessage = this.handleWebSocketMessage.bind(this);
        this.boundOnAppShow = this.onAppShow.bind(this);
        this.boundOnAppHide = this.onAppHide.bind(this);

        // 监听WebSocket消息
        uni.$on('websocket-message', this.boundHandleWebSocketMessage);

        // 监听应用生命周期
        uni.$on('app-show', this.boundOnAppShow);
        uni.$on('app-hide', this.boundOnAppHide);

        this.isInitialized = true;
        console.log('聊天管理器初始化完成');
    }

    /**
     * 用户登录后启动聊天功能
     */
    async startChat() {
        try {
            console.log('启动聊天功能...');

            // 连接WebSocket
            await websocketManager.connect();

            // 加载会话列表
            await this.loadSessions();

            // 计算未读消息总数
            this.updateUnreadCount();

            console.log('聊天功能启动成功');
        } catch (error) {
            console.error('启动聊天功能失败:', error);
        }
    }

    /**
     * 用户登出时停止聊天功能
     */
    stopChat() {
        console.log('停止聊天功能...');

        // 断开WebSocket连接
        websocketManager.disconnect();

        // 清空数据
        this.sessionList = [];
        this.unreadCount = 0;
        this.currentChatUserId = null;

        // 更新UI
        this.notifyUnreadCountChange();

        console.log('聊天功能已停止');
    }

    /**
     * 清理聊天管理器
     */
    cleanup() {
        console.log('清理聊天管理器...');

        // 移除事件监听器
        if (this.boundHandleWebSocketMessage) {
            uni.$off('websocket-message', this.boundHandleWebSocketMessage);
        }
        if (this.boundOnAppShow) {
            uni.$off('app-show', this.boundOnAppShow);
        }
        if (this.boundOnAppHide) {
            uni.$off('app-hide', this.boundOnAppHide);
        }

        // 重置初始化状态
        this.isInitialized = false;

        console.log('聊天管理器清理完成');
    }

    /**
     * 加载会话列表
     */
    async loadSessions() {
        try {
            console.log('开始加载会话列表...');
            const response = await chatApi.getUserSessions();
            if (response.data.code === 200) {
                this.sessionList = response.data.data || [];
                console.log('会话列表加载成功:', this.sessionList.length, '个会话');

                // 触发会话列表更新事件，通知UI更新
                uni.$emit('chat-sessions-updated', this.sessionList);
            } else {
                console.error('加载会话列表失败，响应码:', response.data.code);
            }
        } catch (error) {
            console.error('加载会话列表异常:', error);
        }
    }

    /**
     * 获取会话列表
     */
    getSessions() {
        return this.sessionList;
    }

    /**
     * 处理WebSocket消息
     */
    handleWebSocketMessage(message) {
        console.log('聊天管理器收到消息:', message.type);

        switch (message.type) {
            case 'NEW_MESSAGE':
                this.handleNewMessage(message.data);
                break;
            case 'SEND_SUCCESS':
                this.handleSendSuccess(message.data);
                break;
            case 'SEND_FAILED':
                this.handleSendFailed(message.data);
                break;
            case 'MARK_READ_SUCCESS':
                this.handleMarkReadSuccess(message.data);
                break;
        }

        // 调用注册的消息处理器
        const handler = this.messageHandlers.get(message.type);
        if (handler) {
            handler(message);
        }
    }

    /**
     * 处理新消息
     */
    handleNewMessage(messageData) {
        console.log('收到新消息:', messageData);

        // 确保消息数据格式正确
        if (!messageData || !messageData.senderId) {
            console.error('消息数据格式错误:', messageData);
            return;
        }

        // 更新会话列表
        this.updateSessionWithMessage(messageData);

        // 如果不是当前聊天用户的消息，增加未读数
        if (parseInt(messageData.senderId) !== parseInt(this.currentChatUserId || 0)) {
            this.unreadCount++;
            this.notifyUnreadCountChange();

            // 显示消息通知
            this.showMessageNotification(messageData);
        }

        // 触发新消息事件
        uni.$emit('chat-new-message', messageData);
    }

    /**
     * 处理发送成功
     */
    handleSendSuccess(messageData) {
        console.log('消息发送成功:', messageData);

        // 更新会话列表
        this.updateSessionWithMessage(messageData);

        // 触发发送成功事件
        uni.$emit('chat-send-success', messageData);
    }

    /**
     * 处理发送失败
     */
    handleSendFailed(data) {
        console.log('消息发送失败:', data);

        // 显示错误提示
        uni.showToast({
            title: '发送失败', icon: 'none'
        });

        // 触发发送失败事件
        uni.$emit('chat-send-failed', data);
    }

    /**
     * 处理标记已读成功
     */
    handleMarkReadSuccess(data) {
        console.log('标记已读成功:', data);

        // 触发标记已读成功事件
        uni.$emit('chat-mark-read-success', data);
    }

    /**
     * 更新会话列表中的消息
     */
    updateSessionWithMessage(messageData) {
        console.log('更新会话列表，消息数据:', messageData);
        console.log('当前会话列表:', this.sessionList.map(s => ({id: s.id, type: typeof s.id})));

        // 使用字符串和数字两种方式查找会话，确保能找到
        let session = this.sessionList.find(s => s.id === messageData.sessionId || s.id === String(messageData.sessionId) || String(s.id) === String(messageData.sessionId));

        console.log('找到的会话:', session);

        if (session) {
            // 更新现有会话
            session.lastMessage = messageData.content || '[媒体消息]';
            session.lastMessageTime = messageData.sendTime;

            // 更新未读数
            const currentUser = uni.getStorageSync('userInfo');
            if (currentUser && parseInt(messageData.senderId) !== parseInt(currentUser.id)) {
                if (parseInt(currentUser.id) === parseInt(session.user1Id)) {
                    session.user1UnreadCount = (session.user1UnreadCount || 0) + 1;
                } else {
                    session.user2UnreadCount = (session.user2UnreadCount || 0) + 1;
                }
            }

            // 移动到顶部
            const index = this.sessionList.indexOf(session);
            this.sessionList.splice(index, 1);
            this.sessionList.unshift(session);

            console.log('会话更新完成，移动到顶部');
        } else {
            console.log('未找到对应会话，创建临时会话');
            // 如果没有找到会话，可能是新的会话，创建一个临时会话
            this.createTempSessionForMessage(messageData);
        }

        // 只触发特定会话的更新，而不是整个列表
        console.log('触发会话更新事件，会话数量:', this.sessionList.length);

        // 找到被更新的会话
        const updatedSession = this.sessionList.find(s => s.id === messageData.sessionId || s.id === String(messageData.sessionId) || String(s.id) === String(messageData.sessionId));

        if (updatedSession) {
            // 只传递被更新的会话，而不是整个列表
            uni.$emit('chat-sessions-updated', [updatedSession]);
        } else {
            // 如果是新创建的会话，传递整个列表（但这种情况应该很少）
            console.log('新会话创建，传递完整列表');
            uni.$emit('chat-sessions-updated', this.sessionList);
        }
    }

    /**
     * 为新消息创建临时会话
     */
    createTempSessionForMessage(messageData) {
        console.log('创建临时会话，消息数据:', messageData);

        const currentUser = uni.getStorageSync('userInfo');
        if (!currentUser) {
            console.error('无法获取当前用户信息，无法创建临时会话');
            return;
        }

        // 确定用户角色（谁是user1，谁是user2）
        const isCurrentUserSender = parseInt(messageData.senderId) === parseInt(currentUser.id);

        // 创建临时会话对象
        const tempSession = {
            id: messageData.sessionId,
            user1Id: isCurrentUserSender ? currentUser.id : messageData.senderId,
            user2Id: isCurrentUserSender ? messageData.receiverId : currentUser.id,
            user1Name: isCurrentUserSender ? (currentUser.nickname || currentUser.username) : `用户${messageData.senderId}`,
            user2Name: isCurrentUserSender ? `用户${messageData.receiverId}` : (currentUser.nickname || currentUser.username),
            user1Avatar: isCurrentUserSender ? currentUser.avatar : null,
            user2Avatar: isCurrentUserSender ? null : currentUser.avatar,
            user1Gender: isCurrentUserSender ? (currentUser.gender || 0) : 0,
            user2Gender: isCurrentUserSender ? 0 : (currentUser.gender || 0),
            user1UnreadCount: isCurrentUserSender ? 0 : 1,
            user2UnreadCount: isCurrentUserSender ? 1 : 0,
            lastMessage: messageData.content || '[媒体消息]',
            lastMessageTime: messageData.sendTime,
            status: 0,
            createTime: new Date().toISOString(),
            updateTime: new Date().toISOString()
        };

        // 添加到会话列表顶部
        this.sessionList.unshift(tempSession);
        console.log('临时会话创建完成，添加到列表顶部:', tempSession);

        // 异步获取完整的会话信息
        this.loadSessionDetails(tempSession.id);
    }

    /**
     * 异步加载会话详细信息
     */
    async loadSessionDetails(sessionId) {
        try {
            console.log('异步加载会话详细信息:', sessionId);
            // 这里可以调用API获取完整的会话信息，包括用户头像、昵称等
            // const response = await chatApi.getSessionById(sessionId);
            // 暂时跳过，使用临时数据
        } catch (error) {
            console.error('加载会话详细信息失败:', error);
        }
    }

    /**
     * 显示消息通知
     */
    showMessageNotification(messageData) {
        // 如果应用在前台且不在聊天页面，显示通知
        const pages = getCurrentPages();
        const currentPage = pages[pages.length - 1];
        const route = currentPage.route;

        if (!route.includes('chat/chatDetail')) {

        }
    }

    /**
     * 发送消息
     */
    sendMessage(receiverId, messageType, content, mediaUrl = null) {
        return websocketManager.sendChatMessage(receiverId, messageType, content, mediaUrl);
    }

    /**
     * 标记消息为已读
     */
    async markAsRead(sessionId, receiverId) {
        try {
            // 通过API标记已读
            await chatApi.markMessagesAsRead(sessionId);

            // 通过WebSocket通知
            websocketManager.markAsRead(sessionId);

            // 更新本地未读数
            const session = this.sessionList.find(s => s.id === sessionId);
            if (session) {
                const currentUser = uni.getStorageSync('userInfo');
                if (currentUser.id === session.user1Id) {
                    this.unreadCount -= session.user1UnreadCount || 0;
                    session.user1UnreadCount = 0;
                } else {
                    this.unreadCount -= session.user2UnreadCount || 0;
                    session.user2UnreadCount = 0;
                }

                this.unreadCount = Math.max(0, this.unreadCount);
                this.notifyUnreadCountChange();
            }

        } catch (error) {
            console.error('标记已读失败:', error);
        }
    }

    /**
     * 设置当前聊天用户
     */
    setCurrentChatUser(userId) {
        this.currentChatUserId = userId;
        console.log('设置当前聊天用户:', userId);
    }

    /**
     * 清除当前聊天用户
     */
    clearCurrentChatUser() {
        this.currentChatUserId = null;
        console.log('清除当前聊天用户');
    }

    /**
     * 更新未读消息总数
     */
    updateUnreadCount() {
        const currentUser = uni.getStorageSync('userInfo');
        if (!currentUser) return;

        this.unreadCount = 0;
        this.sessionList.forEach(session => {
            if (currentUser.id === session.user1Id) {
                this.unreadCount += session.user1UnreadCount || 0;
            } else {
                this.unreadCount += session.user2UnreadCount || 0;
            }
        });

        this.notifyUnreadCountChange();
    }

    /**
     * 通知未读消息数变化
     */
    notifyUnreadCountChange() {
        console.log('未读消息总数:', this.unreadCount);

        // 更新tabBar红点
        if (this.unreadCount > 0) {
            uni.setTabBarBadge({
                index: 2, // 消息tab的索引，需要根据实际情况调整
                text: this.unreadCount > 99 ? '99+' : this.unreadCount.toString()
            });
        } else {
            uni.removeTabBarBadge({
                index: 2
            });
        }

        // 触发未读数变化事件
        uni.$emit('chat-unread-count-changed', this.unreadCount);
    }

    /**
     * 注册消息处理器
     */
    onMessage(type, handler) {
        this.messageHandlers.set(type, handler);
    }

    /**
     * 移除消息处理器
     */
    offMessage(type) {
        this.messageHandlers.delete(type);
    }

    /**
     * 获取会话列表
     */
    getSessions() {
        return this.sessionList;
    }

    /**
     * 获取未读消息总数
     */
    getUnreadCount() {
        return this.unreadCount;
    }

    /**
     * 获取WebSocket连接状态
     */
    getConnectionState() {
        return websocketManager.getConnectionState();
    }

    /**
     * 应用显示时的处理
     */
    onAppShow() {
        console.log('应用显示，检查聊天连接状态');

        // 如果用户已登录但WebSocket未连接，尝试重连
        const token = uni.getStorageSync('token');
        if (token && !websocketManager.isConnected) {
            this.startChat();
        }
    }

    /**
     * 应用隐藏时的处理
     */
    onAppHide() {
        console.log('应用隐藏');
        // 可以在这里做一些清理工作
    }
}

// 创建全局实例
let chatManager = null;

// 延迟初始化，确保uni对象已经准备好
function createChatManager() {
    if (!chatManager) {
        console.log('创建聊天管理器实例');
        chatManager = new ChatManager();
    }
    return chatManager;
}

// 导出工厂函数和实例
export default createChatManager();
